hysop.backend.host.host_array_backend module

class hysop.backend.host.host_array_backend.HostArrayBackend(allocator, **kwds)

Bases: ArrayBackend

Host array backend.

Initialize an ArrayBackend with guven allocator.

absolute(x, out=None)

Calculate the absolute value element-wise.

add(x1, x2, out=None)

Add arguments element-wise.

all(a, axis=None, out=None)

Test whether all array elements along a given axis evaluate to True.

allclose(a, b, rtol=1e-05, atol=1e-08, equal_nan=False)

Returns True if two arrays are element-wise equal within a tolerance.

amax(a, axis=None, out=None)

Return the maximum of an array or maximum along an axis.

amin(a, axis=None, out=None)

Return the minimum of an array or minimum along an axis.

angle(z, deg=False)

Return the angle of the complex argument.

any(a, axis=None, out=None)

Test whether any array elements along a given axis evaluate to True.

append(arr, values, axis=None)

Append values to the end of an array.

arange(*args, **kargs)

Return evenly spaced values within a given interval. Data is not allocated from backend allocator.

arccos(x, out=None)

Trigonometric inverse cosine, element-wise.

arccosh(x, out=None)

Inverse hyperbolic cosine, element-wise.

arcsin(x, out=None)

Inverse sine, element-wise.

arcsinh(x, out=None)

Inverse hyperbolic sine element-wise.

arctan(x, out=None)

Trigonometric inverse tangent, element-wise.

arctan2(x1, x2, out=None)

Element-wise arc tangent of x1/x2 choosing the quadrant correctly.

arctanh(x, out=None)

Inverse hyperbolic tangent element-wise.

argmax(a, axis, out=None)

Returns the indices of the maximum values along an axis.

argmin(a, axis, out=None)

Returns the indices of the minimum values along an axis.

argpartition(a, kth, axis=-1, kind='quicksort', order=None)

Perform an indirect partition along the given axis using the algorithm specified by the kind keyword.

argsort(a, axis=-1, kind='quicksort', order=None)

Returns the indices that would sort an array.

argwhere(a)

Find the indices of array elements that are non-zero, grouped by element.

around(a, decimals=0, out=None)

Evenly round to the given number of decimals.

array(shape, dtype=<class 'numpy.float64'>, order=C_CONTIGUOUS(0), min_alignment=None, buf=None, offset=0)

Create a HostArray, see np.ndarray constructor. If buf is None, a new one is allocated from backend allocator.

array2string(a, max_line_width=None, precision=None, suppress_small=None, separator=' ', prefix='', style=<built-in function repr>, formatter=None)

Return a string representation of an array.

array_equal(a1, a2)

True if two arrays have the same shape and elements, False otherwise.

array_equiv(a1, a2)

returns True if input arrays are shape consistent and all elements equal.

array_repr(arr, max_line_width=None, precision=None, supress_small=None)

Return the string representation of an array.

array_split(ary, indices_or_sections, axis=0)

Split an array into multiple sub-arrays.

array_str(a, max_line_width=None, precision=None, suppress_small=None)

Return a string representation of the data in an array.

asanyarray(a, dtype=None, order=C_CONTIGUOUS(0))

Convert the input to an ndarray, but pass ndarray subclasses through. Data is not allocated from backend allocator.

asarray(a, dtype=None, order=C_CONTIGUOUS(0))

Convert the input to an HostArray. Data is not allocated from backend allocator.

asarray_chkfinite(a, dtype=None, order=C_CONTIGUOUS(0))

Convert the input to an array, checking for NaNs or Infs.

ascontiguousarray(a, dtype=None)

Return a contiguous array in memory (C order).

asfortranarray(a, dtype=None)

Return an array laid out in Fortran order in memory.

asmatrix(data, dtype=None)

Interpret the input as a matrix. Data is not allocated from backend allocator.

asscalar(a)

Convert an array of size 1 to its scalar equivalent.

atleast_1d(*arys)

Convert inputs to arrays with at least one dimension.

atleast_2d(*arys)

View inputs as arrays with at least two dimensions.

atleast_3d(*arys)

View inputs as arrays with at least three dimensions.

average(a, axis=None, weights=None, returned=False)

Compute the weighted average along the specified axis.

base_repr(number, base=2, padding=0)

Return a string representation of a number in the given base system.

beta(a, b, size=None)

Draw samples from a Beta distribution.

binary_repr(num, width=None)

Return the binary representation of the input number as a string.

bincount(x, weights=None, minlength=None)

Count number of occurrences of each value in array of non-negative ints.

binomial(n, p, size=None)

Draw samples from a binomial distribution.

bitwise_and(x1, x2, out=None)

Compute the bit-wise AND of two arrays element-wise.

bitwise_or(x1, x2, out=None)

Compute the bit-wise OR of two arrays element-wise.

bitwise_xor(x1, x2, out=None)

Compute the bit-wise XOR of two arrays element-wise.

broadcast_arrays(*args, **kwargs)

Broadcast any number of arrays against each other.

broadcast_to(array, shape, subok=False)

Broadcast an array to a new shape.

bytes(length)

Return random bytes.

can_wrap(handle)

Should return True if handle is an Array or a array handle corresponding this backend.

cbrt(x, out=None)

Return the cube-root of an array, element-wise.

ceil(x, out=None)

Return the ceiling of the input, element-wise.

chisquare(df, size=None)

Draw samples from a chi-square distribution.

choice(a, size=None, replace=True, p=None)

Generates a random sample from a given 1-D array

cholesky(a)

Cholesky decomposition.

clip(a, a_min, a_max, out=None)

Clip (limit) the values in an array.

clip_components(a, a_min, a_max, out=None)

Clip (limit) the values in an array.

column_stack(tup)

Stack 1-D arrays as columns into a 2-D array.

concatenate(a, axis=0)

Join a sequence of arrays along an existing axis.

cond(x, p=None)

Compute the condition number of a matrix.

conj(x, out=None)

Return the complex conjugate, element-wise.

convolve(a, v, mode='full')

Returns the discrete, linear convolution of two one-dimensional sequences.

copy(a, order=SAME_ORDER(3))

Return an array copy of the given object.

copysign(x1, x2, out=None)

Change the sign of x1 to that of x2, element-wise.

copyto(dst, src, reshape=False, queue=None, synchronize=True, **kwds)

src is a HostArray dst can be everything

corrcoef(x, y, rowvar=1)

Return Pearson product-moment correlation coefficients.

correlate(a, v, mode='valid')

Cross-correlation of two 1-dimensional sequences.

cos(x, out=None)

Cosine element-wise.

cosh(x, out=None)

Hyperbolic cosine, element-wise.

count_nonzero(a, axis=None)

Counts the number of non-zero values in the array a.

cov(m, y=None, rowvar=True, bias=False, ddof=None, fweights=None, aweights=None)

Estimate a covariance matrix, given data and weights.

cross(a, b, axisa=-1, axisb=-1, axisc=-1, axis=None)

Return the cross product of two (arrays of) vectors.

cumprod(a, axis=None, dtype=None, out=None)

Return the cumulative product of elements along a given axis.

cumsum(a, axis=None, dtype=None, out=None)

Return the cumulative sum of the elements along a given axis.

deg2rad(x, out=None)

Convert angles from degrees to radians.

delete(arr, obj, axis=None)

Return a new array with sub-arrays along an axis deleted.

det(a)

Compute the determinant of an array.

diag(v, k=0)

Extract a diagonal or construct a diagonal array. Data is not allocated from backend allocator.

diagflat(v, k=0)

Create a two-dimensional array with the flattened input as a diagonal. Data is not allocated from backend allocator.

diff(a, n=1, axis=-1)

Calculate the n-th discrete difference along given axis.

digitize(x, bins, right=False)

Return the indices of the bins to which each value in input array belongs.

dirichlet(alpha, size=None)

Draw samples from the Dirichlet distribution.

divide(x1, x2, out=None)

Divide arguments element-wise.

dot(a, b, out=None)

Dot product of two arrays.

dsplit(ary, indices_or_sections)

Split array into multiple sub-arrays along the 3rd axis (depth).

dstack(tup)

Stack arrays in sequence depth wise (along third axis).

ediff1d(ary, to_end=None, to_begin=None)

The differences between consecutive elements of an array.

eig(a)

Compute the eigenvalues and right eigenvectors of a square array.

eigh(a, UPLO='L')

Return the eigenvalues and eigenvectors of a Hermitian or symmetric matrix.

eigvals(a)

Compute the eigenvalues of a general matrix.

eigvalsh(a, UPLO='L')

Compute the eigenvalues of a Hermitian or real symmetric matrix.

einsum(subscripts, out=None, dtype=None, order=SAME_ORDER(3), casting='safe', optimize=False, *operands)

Evaluates the Einstein summation convention on the operands.

empty(shape, dtype=<class 'numpy.float64'>, order=C_CONTIGUOUS(0), min_alignment=None)

Return a new array of given shape and type, without initializing entries. Data is allocated from backend allocator.

empty_like(a, dtype=None, order=None, subok=True, shape=None)

Return a new array with the same shape and type as a given array. Data is allocated from backend allocator.

equal(x1, x2, out=None)

Return (x1 == x2) element-wise.

exp(x, out=None)

Calculate the exponential of all elements in the input array.

exp2(x, out=None)

Calculate 2**p for all p in the input array.

expand_dims(a, axis)

Expand the shape of an array.

expm1(x, out=None)

Calculate exp(x) - 1 for all elements in the array.

exponential(scale=1.0, size=None)

Draw samples from an exponential distribution.

extract(condition, arr)

Return the elements of an array that satisfy some condition.

eye(N, M, k, dtype=None)

Return a 2-D array with ones on the diagonal and zeros elsewhere. Data is not allocated from backend allocator.

f(dfnum, dfden, size=None)

Draw samples from an F distribution.

fabs(x, out=None)

Calculate the absolute value element-wise, outputs HYSOP_REAL unless out is set.

fft(a, n=None, axis=-1, norm=None)

Compute the one-dimensional discrete Fourier Transform.

fft2(a, s=None, axes=None, norm=None)

Compute the 2-dimensional discrete Fourier Transform

fftfreq(n=None, d=1.0)

Return the Discrete Fourier Transform sample frequencies.

fftn(a, s=None, axes=None, norm=None)

Compute the N-dimensional discrete Fourier Transform.

fftshift(x, axes=None)

Shift the zero-frequency component to the center of the spectrum.

fill(a, value)

Fill the array with given value.

fix(x, y=None)

Round to nearest integer towards zero.

flatnonzero(a)

Return indices that are non-zero in the flattened version of a.

flip(m, axis)

Reverse the order of elements in an array along the given axis.

fliplr(m)

Flip array in the left/right direction.

flipud(m)

Flip array in the up/down direction.

floor(x, out=None)

Return the floor of the input, element-wise.

floor_divide(x1, x2, out=None)

Return the largest integer smaller or equal to the division of the inputs.

fmax(x1, x2, out=None)

Element-wise minimum of array elements, ignore NaNs.

fmin(x1, x2, out=None)

Element-wise maximum of array elements, ignore NaNs.

fmod(x1, x2, out=None)

Return the element-wise remainder of division.

frexp(x, out1=None, out2=None)

Decompose the elements of x into mantissa and twos exponent.

frombuffer(afer, dtype=<class 'numpy.float64'>, count=-1, offset=0)

Interpret a afer as a 1-dimensional array. Data is not allocated from backend allocator.

fromfile(file, dtype=<class 'numpy.float64'>, count=-1, sep='')

Construct an array from data in a text or binary file. Data is not allocated from backend allocator.

fromfunction(function, shape, dtype=<class 'numpy.float64'>)

Construct an array by executing a function over each coordinate. Data is not allocated from backend allocator.

fromiter(iterable, dtype=<class 'numpy.float64'>, count=-1)

Create a new 1-dimensional array from an iterable object. Data is not allocated from backend allocator.

frompyfunc(func, nin, nout)

Takes an arbitrary Python function and returns a NumPy ufunc.

fromregex(file, regexp, dtype)

Construct an array from a text file, using regular expression parsing.

fromstring(string, dtype=<class 'numpy.float64'>, count=-1, sep='')

A new 1-D array initialized from raw binary or text data in a string.

full(shape, fill_value, dtype=<class 'numpy.float64'>, order=C_CONTIGUOUS(0), min_alignment=None)

Return a new array of given shape and type, filled with fill_value. Data is allocated from backend allocator.

full_like(a, fill_value, dtype=None, order=None, subok=True, shape=None)

Return a new array with the same shape and type as a given array. Data is allocated from backend allocator.

gamma(shape, scale=1.0, size=None)

Draw samples from a Gamma distribution.

genfromtxt(fname, dtype=<class 'numpy.float64'>, comments='#', delimiter=None, skip_header=0, skip_footer=0, converters=None, missing_values=None, filling_values=None, usecols=None, names=None, excludelist=None, deletechars=None, replace_space='_', autostrip=False, case_sensitive=True, defaultfmt='f%i', unpack=None, usemask=False, loose=True, invalid_raise=True, max_rows=None)

Load data from a text file, with missing values handled as specified.

geometric(p, size=None)

Draw samples from the geometric distribution.

geomspace(start, stop, num=50, endpoint=True, dtype=<class 'numpy.float64'>)

Return numbers spaced evenly on a log scale (a geometric progression). Data is not allocated from backend allocator.

get_host_array_backend()

get_kind()

classmethod get_or_create(allocator)

get_printoptions()

Return the current print options.

get_state()

Return a tuple representing the internal state of the generator.

gradient(f, *varargs, **kwargs)

Return the gradient of an N-dimensional array.

greater(x1, x2, out=None)

Return the truth value of (x1 > x2) element-wise.

greater_equal(x1, x2, out=None)

Return the truth value of (x1 >= x2) element-wise.

gumbel(loc=0.0, scale=1.0, size=None)

Draw samples from a Gumbel distribution.

hfft(a, n=None, axis=-1, norm=None)

Compute the FFT of a signal that has Hermitian symmetry, i.e., a real spectrum.

histogram(a, bins=10, range=None, normed=False, weights=None, density=None)

Compute the histogram of a set of data.

histogram2d(x, y, bins, range=None, normed=False, weights=None)

Compute the bi-dimensional histogram of two data samples.

histogramdd(sample, bins, range=None, normed=False, weights=None)

Compute the multidimensional histogram of some data.

property host_array_backend

hsplit(ary, indices_or_sections)

Split an array into multiple sub-arrays horizontally (column-wise).

hstack(tup)

Stack arrays in sequence horizontally (column wise).

hypergeometric(ngood, nbad, nsample, size=None)

Draw samples from a Hypergeometric distribution.

hypot(x1, x2, out=None)

Given the legs of a right triangle, return its hypotenuse.

i0(x)

Modified Bessel function of the first kind, order 0.

identity(n, dtype=None)

Return the identity array. Data is not allocated from backend allocator.

ifft(a, n=None, axis=-1, norm=None)

Compute the one-dimensional inverse discrete Fourier Transform.

ifft2(a, s=None, axes=None, norm=None)

Compute the 2-dimensional inverse discrete Fourier Transform.

ifftn(a, s=None, axes=None, norm=None)

Compute the N-dimensional inverse discrete Fourier Transform.

ifftshift(x, axes=None)

The inverse of fftshift.

ihfft(a, n=None, axis=-1, norm=None)

Compute the inverse FFT of a signal that has Hermitian symmetry.

imag(val)

Return the imaginary part of the elements of the array.

in1d(ar1, ar2, assume_unique=False, invert=False)

Test whether each element of a 1-D array is also present in a second array.

inner(a, b)

Inner product of two arrays.

insert(arr, obj, values, axis=None)

Insert values along the given axis before the given indices.

interp(x, xp, fp, left=None, right=None, period=None)

One-dimensional linear interpolation.

intersect1d(ar1, ar2, assume_unique=False)

Find the intersection of two arrays.

inv(a)

Compute the (multiplicative) inverse of a matrix.

invert(x, out=None)

Compute bit-wise inversion, or bit-wise NOT, element-wise.

irfft(a, n=None, axis=-1, norm=None)

Compute the inverse of the n-point DFT for real input.

irfft2(a, s=None, axes=(-2, -1), norm=None)

Compute the 2-dimensional inverse FFT of a real array.

irfftn(a, s=None, axes=None, norm=None)

Compute the inverse of the N-dimensional FFT of real input.

isclose(a, b, rtol=1e-05, atol=1e-08, equal_nan=False)

Returns a boolean array where two arrays are element-wise equal within a tolerance.

isfinite(x, out=None)

Test element-wise for finiteness (not infinity or not Not a Number).

isinf(x, out=None)

Test element-wise for positive or negative infinity.

isnan(x, out=None)

Test element-wise for NaN and return result as a boolean array.

isneginf(x, out=None)

Test element-wise for negative infinity, return result as bool array.

isposinf(x, out=None)

Test element-wise for positive infinity, return result as bool array.

property kind

kron(a, b)

Kronecker product of two arrays.

laplace(loc=0.0, scale=1.0, size=None)

Draw samples from the Laplace or double exponential distribution with specified location (or mean=0.0) and scale (decay).

ldexp(x1, x2, out=None)

Returns x1 * 2**x2, element-wise.

left_shift(x1, x2, out=None)

Shift the bits of an integer to the left.

less(x1, x2, out=None)

Return the truth value of (x1 < x2) element-wise.

less_equal(x1, x2, out=None)

Return the truth value of (x1 =< x2) element-wise.

lexsort(keys, axis=-1)

Perform an indirect sort using a sequence of keys.

linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=<class 'numpy.float64'>)

Return evenly spaced numbers over a specified interval. Data is not allocated from backend allocator.

load(mmap_mode=None, allow_pickle=True, fix_imports=True, encoding='ASCII')

Load arrays or pickled objects from .npy, .npz or pickled files.

loadtxt(dtype=<class 'numpy.float64'>, comments='#', delimiter=None, converters=None, skiprows=0, usecols=None, unpack=False, ndmin=0)

Load data from a text file.

log(x, out=None)

Natural logarithm, element-wise.

log10(x, out=None)

Return the base 10 logarithm of the input array, element-wise.

log1p(x, out=None)

Return the natural logarithm of one plus the input array, element-wise.

log2(x, out=None)

Base-2 logarithm of x.

logaddexp(x1, x2, out=None)

Logarithm of the sum of exponentiations of the inputs.

logaddexp2(x1, x2, out=None)

Logarithm of the sum of exponentiations of the inputs in base-2.

logical_and(x1, x2, out=None)

Compute the truth value of x1 AND x2 element-wise.

logical_not(x, out=None)

Compute the truth value of NOT x element-wise.

logical_or(x1, x2, out=None)

Compute the truth value of x1 OR x2 element-wise.

logical_xor(x1, x2, out=None)

Compute the truth value of x1 XOR x2, element-wise.

logistic(loc=0.0, scale=1.0, size=None)

Draw samples from a logistic distribution.

lognormal(mean=0.0, sigma=1.0, size=None)

Draw samples from a log-normal distribution.

logseries(p, size=None)

Draw samples from a logarithmic series distribution.

logspace(start, stop, num=50, endpoint=True, base=10.0, dtype=<class 'numpy.float64'>)

Return numbers spaced evenly on a log scale. Data is not allocated from backend allocator.

lstsq(a, b, rcond=-1)

Return the least-squares solution to a linear matrix equation.

matmul(a, b, out=None)

Matrix product of two arrays.

matrix_power(M, n)

Raise a square matrix to the integer power n.

matrix_rank(M, tol=None)

Return matrix rank of array using SVD method

maximum(x1, x2, out=None)

Element-wise maximum of array elements.

mean(a, axis=None, dtype=None, out=None)

Compute the arithmetic mean along the specified axis.

median(a, axis=None, out=None, overwrite_input=False)

Compute the median along the specified axis.

meshgrid(*xi, **kwargs)

Return coordinate matrices from coordinate vectors. Data is not allocated from backend allocator.

minimum(x1, x2, out=None)

Element-wise minimum of array elements.

mod(x1, x2, out=None)

Return element-wise remainder of division.

modf(x, out1=None, out2=None)

Return the fractional and integral parts of an array, element-wise.

moveaxis(a, source, destination)

Move axes of an array to new positions.

msort(a)

Return a copy of an array sorted along the first axis.

multinomial(n, pvals, size=None)

Draw samples from a multinomial distribution.

multiply(x1, x2, out=None)

Multiply arguments element-wise.

multivariate_normal(mean, cov, size=None)

Draw random samples from a multivariate normal distribution.

nan_to_num(x)

Replace nan with zero and inf with finite numbers.

nanargmax(a, axis=None)

Return the indices of the maximum values in the specified axis ignoring NaNs.

nanargmin(a, axis=None)

Return the indices of the minimum values in the specified axis ignoring NaNs.

nancumprod(a, axis=None, dtype=None, out=None)

Return the cumulative product of array elements over a given axis treating Not a Numbers (NaNs) as one.

nancumsum(a, axis=None, dtype=None, out=None)

Return the cumulative sum of array elements over a given axis treating Not a Numbers (NaNs) as zero.

nanmax(a, axis=None, out=None)

Return the maximum of an array or maximum along an axis, ignoring any NaNs.

nanmean(a, axis=None, dtype=None, out=None)

Compute the arithmetic mean along the specified axis, ignoring NaNs.

nanmedian(a, axis=None, out=None, overwrite_input=False)

Compute the median along the specified axis, while ignoring NaNs.

nanmin(a, axis=None, out=None)

Return minimum of an array or minimum along an axis, ignoring any NaNs.

nanpercentile(a, q, axis=None, out=None, overwrite_input=False, interpolation='linear')

Compute the qth percentile of the data along the specified axis, while ignoring nan values.

nanprod(a, axis=None, dtype=None, out=None)

Return the product of array elements over a given axis treating Not a Numbers (NaNs) as ones.

nanstd(a, axis=None, dtype=None, out=None, ddof=0)

Compute the standard deviation along the specified axis, while ignoring NaNs.

nansum(a, axis=None, dtype=None, out=None)

Return the sum of array elements over a given axis treating Not a Numbers (NaNs) as zero.

nanvar(a, axis=None, dtype=None, out=None, ddof=0)

Compute the variance along the specified axis, while ignoring NaNs.

negative(x, out=None)

Numerical negative, element-wise.

negative_binomial(n, p, size=None)

Draw samples from a negative binomial distribution.

noncentral_chisquare(df, nonc, size=None)

Draw samples from a noncentral chi-square distribution.

noncentral_f(dfnum, dfden, nonc, size=None)

Draw samples from the noncentral F distribution.

nonzero(a)

Return the indices of the elements that are non-zero.

norm(x, ord=None, axis=None, keepdims=False)

Matrix or vector norm.

normal(loc=0.0, scale=1.0, size=None)

Draw random samples from a normal (Gaussian) distribution.

not_equal(x1, x2, out=None)

Return (x1 != x2) element-wise.

ones(shape, dtype=<class 'numpy.float64'>, order=C_CONTIGUOUS(0), min_alignment=None)

Return a new array of given shape and type, filled with ones. Data is allocated from backend allocator.

ones_like(a, dtype=None, order=None, subok=True, shape=None)

Return an array of ones with the same shape and type as a given array. Data is allocated from backend allocator.

outer(a, b, out=None)

Compute the outer product of two vectors.

packbits(myarray, axis=None)

Packs the elements of a binary-valued array into bits in a uint8 array.

pareto(a, size=None)

Draw samples from a Pareto II or Lomax distribution with specified shape.

partition(a, kth, axis=-1, kind='quicksort', order=None)

Return a partitioned copy of an array.

percentile(a, q, axis=None, out=None, overwrite_input=False, interpolation='linear')

Compute the qth percentile of the data along the specified axis.

permutation(x)

Randomly permute a sequence, or return a permuted range.

piecewise(x, condlist, funclist, *args, **kw)

Evaluate a piecewise-defined function.

pinv(a, rcond=1e-15)

Compute the (Moore-Penrose) pseudo-inverse of a matrix.

poisson(lam, size=None)

Draw samples from a Poisson distribution.

power(a, size=None)

Draws samples in 0, 1 from a power distribution with positive exponent a - 1.

prod(a, axis=None, dtype=None, out=None)

Return the product of array elements over a given axis.

ptp(a, axis=None, out=None)

Range of values (maximum - minimum) along an axis.

qr(a, mode='reduced')

Compute the qr factorization of a matrix.

rad2deg(x, out=None)

Convert angles from radians to degrees.

rand(shape=None, out=None)

Random values in a given shape.

randint(low, high=None, size=None, dtype=<class 'numpy.int32'>)

Return random integers from low (inclusive) to high (exclusive).

randn(*args)

Return a sample (or samples) from the ‘standard normal’ distribution.

random(size=None)

Return random floats in the half-open interval 0.0, 1.0).

random_integers(low, high=None, size=None)

Random integers of type np.int between low and high, inclusive.

random_sample(size=None)

Return random floats in the half-open interval 0.0, 1.0).

ranf(size=None)

Return random floats in the half-open interval 0.0, 1.0).

ravel(a, order=SAME_ORDER(3))

Return a contiguous flattened array.

rayleigh(scale=1.0, size=None)

Draw samples from a Rayleigh distribution.

real(val)

Return the real part of the elements of the array.

real_if_close(a, tol=100)

If complex input returns a real array if complex parts are close to zero.

reciprocal(x, out=None)

Return the reciprocal of the argument, element-wise.

repeat(a, repeats, axis=None)

Repeat elements of an array.

require(a, dtype=None, requirements=None)

Return an ndarray of the provided type that satisfies requirements.

reshape(a, newshape, order=C_CONTIGUOUS(0))

Gives a new shape to an array without changing its data.

resize(a, new_shape)

Return a new array with the specified shape.

rfft(a, n=None, axis=-1, norm=None)

Compute the one-dimensional discrete Fourier Transform for real input.

rfft2(a, s=None, axes=(-2, -1), norm=None)

Compute the 2-dimensional FFT of a real array.

rfftfreq(n=None, d=1.0)

Return the Discrete Fourier Transform sample frequencies (for usage with rfft, irfft).

rfftn(a, s=None, axes=None, norm=None)

Compute the N-dimensional discrete Fourier Transform for real input.

right_shift(x1, x2, out=None)

Shift the bits of an integer to the right.

rint(x, out=None)

Round elements of the array to the nearest integer.

roll(a, shift, axis=None)

Roll array elements along a given axis.

rollaxis(a, axis, start=0)

Roll the specified axis backwards, until it lies in a given position.

rot90(m, k=1, axes=(0, 1))

Rotate an array by 90 degrees in the plane specified by axes.

sample(size=None)

Return random floats in the half-open interval 0.0, 1.0).

save(arr, file, allow_pickle=True, fix_imports=True)

Save an array to a binary file in NumPy .npy format.

savetxt(fname, X, fmt='%.18e', delimiter=' ', newline='\n', header='', footer='', comments='# ')

Save an array to a text file.

savez(file, *args, **kwds)

Save several arrays into a single file in uncompressed .npz format.

savez_compressed(file, *args, **kwds)

Save several arrays into a single file in compressed .npz format.

searchsorted(a, v, side='left', sorter=None)

Find indices where elements should be inserted to maintain order.

seed(seed=None)

Seed the generator.

set_printoptions(precision=None, threshold=None, edgeitems=None, linewidth=None, suppress=None, nanstr=None, infstr=None, formatter=None)

Set printing options.

set_state(state)

Set the internal state of the generator from a tuple.

set_string_function(f, repr=True)

Set a Python function to be used when pretty printing arrays.

setdiff1d(ar1, ar2, assume_unique=False)

Find the set difference of two arrays.

setxor1d(ar1, ar2, assume_unique=False)

Find the set exclusive-or of two arrays.

short_description()

shuffle(x)

Modify a sequence in-place by shuffling its contents.

sign(x, out=None)

Returns an element-wise indication of the sign of a number.

signbit(x, out=None)

Returns element-wise True where signbit is set (less than zero).

sin(x, out=None)

Trigonometric sine, element-wise.

sinc(x)

Return the sinc function.

sinh(x, out=None)

Hyperbolic sine, element-wise.

slogdet(a)

Compute the sign and natural logarithm of the determinant of an array.

solve(a, b)

Solve a linear matrix equation, or system of linear scalar equations.

sort(a, axis=-1, kind='quicksort', order=None)

Return a sorted copy of an array.

sort_complex(a)

Sort a complex array using the real part first, then the imaginary part.

split(ary, indices_or_sections, axis=0)

Split an array into multiple sub-arrays.

sqrt(x, out=None)

Return the positive square-root of an array, element-wise.

square(x, out=None)

Return the element-wise square of the input.

squeeze(a, axis=None)

Remove single-dimensional entries from the shape of an array.

stack(arrays, axis=0)

Join a sequence of arrays along a new axis.

standard_cauchy(size=None)

Draw samples from a standard Cauchy distribution with mode = 0.

standard_exponential(size=None)

Draw samples from the standard exponential distribution.

standard_gamma(shape, size=None)

Draw samples from a standard Gamma distribution.

standard_normal(size=None)

Draw samples from a standard Normal distribution (mean=0.0, stdev=1).

standard_t(df, size=None)

Draw samples from a standard Student’s t distribution with df degrees of freedom.

std(a, axis=None, dtype=None, out=None, ddof=0)

Compute the standard deviation along the specified axis.

subtract(x1, x2, out=None)

Subtract arguments, element-wise.

sum(a, axis=None, dtype=None, out=None)

Sum of array elements over a given axis.

svd(a, full_matrices=True, compute_uv=True)

Singular Value Decomposition.

swapaxes(a, axis1, axis2)

Interchange two axes of an array.

tan(x, out=None)

Compute tangent element-wise.

tanh(x, out=None)

Compute hyperbolic tangent element-wise.

tensordot(a, b, axes=2)

Compute tensor dot product along specified axes for arrays >= 1-D.

tensorinv(a, ind=2)

Compute the ‘inverse’ of an N-dimensional array.

tensorsolve(a, b, axes=None)

Solve the tensor equation a x = b for x.

tile(A, reps)

Construct an array by repeating A the number of times given by reps.

trace(a, offset=0, axis1=0, axis2=1, dtype=None, out=None)

Return the sum along diagonals of the array.

transpose(a, axes=None)

Permute the dimensions of an array.

trapz(y, x=None, dx=1.0, axis=-1)

Integrate along the given axis using the composite trapezoidal rule.

tri(N, M=None, k=0, dtype=<class 'numpy.float64'>)

An array with ones at and below the given diagonal and zeros elsewhere. Data is not allocated from backend allocator.

triangular(left, mode, right, size=None)

Draw samples from the triangular distribution over the interval left, right.

tril(m, k)

Lower triangle of an array. Data is not allocated from backend allocator.

trim_zeros(filt, trim='fb')

Trim the leading and/or trailing zeros from a 1-D array or sequence.

triu(m, k=0)

Upper triangle of an array. Data is not allocated from backend allocator.

true_divide(x1, x2, out=None)

Returns a true division of the inputs, element-wise.

trunc(x, out=None)

Return the truncated value of the input, element-wise.

uniform(low, high, size=None)

Draw samples from a uniform distribution.

union1d(ar1, ar2)

Find the union of two arrays.

unique(ar, return_index=False, return_inverse=False, return_counts=False)

Find the unique elements of an array.

unpackbits(myarray, axis=None)

Unpacks elements of a uint8 array into a binary-valued output array.

unwrap(p, discont=3.141592653589793, axis=-1)

Unwrap by changing deltas between values to 2*pi complement.

vander(x, N=None, increasing=False)

Generate a Vandermonde matrix. Data is not allocated from backend allocator.

var(a, axis=None, dtype=None, out=None, ddof=0)

Compute the variance along the specified axis.

vdot(a, b)

Return the dot product of two vectors.

vectorize(pyfunc, otypes=None, doc=None, excluded=None, cache=False, signature=None)

Generalized function class.

vonmises(mu, kappa, size=None)

Draw samples from a von Mises distribution.

vsplit(ary, indices_or_sections)

Split an array into multiple sub-arrays vertically (row-wise).

vstack(tup)

Stack arrays in sequence vertically (row wise).

wald(mean=0.0, scale=1.0, size=None)

Draw samples from a Wald, or inverse Gaussian, distribution.

weibull(a, size=None)

Draw samples from a Weibull distribution.

where(condition, x, y)

Return elements, either from x or y, depending on condition.

wrap(handle)

Create a HostArray from an np.ndarray instance.

zeros(shape, dtype=<class 'numpy.float64'>, order=C_CONTIGUOUS(0), min_alignment=None)

Return a new array of given shape and type, filled with zeros. Data is allocated from backend allocator.

zeros_like(a, dtype=None, order=None, subok=True, shape=None)

Return an array of zeros with the same shape and type as a given array. Data is allocated from backend allocator.

zipf(a, size=None)

Draw samples from a Zipf distribution.

hysop.backend.host.host_array_backend.numpy_method(f)